package cc.loac.heba.service;

import cc.loac.heba.dao.HeiDao;
import cc.loac.heba.pojo.*;
import cc.loac.heba.tool.Common;
import cc.loac.heba.tool.MyCOSClient;
import com.alibaba.fastjson.JSONObject;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import java.io.File;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.UUID;

@Service
public class HeiService {

    @Resource
    HeiDao heiDao;

    @Resource
    LoginTokenService loginTokenService;

    @Resource
    UserService userService;

    @Resource
    MessageService messageService;

    /**
     * 获取嘿文
     * @param schoolName 学校名
     * @param token token
     * @return Result
     */
    public String getHeis(String email, String schoolName, String token) {
        Result result;
        try {
            result = tokenIsExpired(email, token);
            if (result.getStatus() != 0) {
                // Token 有问题，返回原因
                return Common.toJson(result);
            }

            List<Hei> heis;
            if (schoolName != null && !schoolName.equals("")) {
                // 传入学校，获取指定学校嘿文
                heis = getHeiBySchool(schoolName);
            } else {
                // 未传入学校，获取所有嘿文
                heis = getAllHei();
            }

            // 根据嘿文 ID 获取对应的图像并加入 Hei
            // 因为这里获取的是批量嘿文用于预览，所以只获取最少一张图像
            heis = getHeiAndImageByHeiList(heis, 1);

            result.setContent(heis);
            return Common.toJson(result);
        } catch (Exception e) {
            e.printStackTrace();
            return Common.exceptionResults();
        }
    }

    /**
     * 根据嘿文 ID 获取嘿文
     * @param email 邮箱
     * @param id 嘿文 ID
     * @param token Token
     * @return Result
     */
    public String getHeiById(String email, String id, String token) {
        Result result;
        try {
            result = tokenIsExpired(email, token);
            if (result.getStatus() != 0) {
                // Token 有问题，返回原因
                return Common.toJson(result);
            }

            // 获取嘿文
            Hei hei = heiDao.selectHeiById(id);
            if (hei == null) {
                result.setStatus(-2);
                result.setMessage("嘿文不存在");
                return Common.toJson(result);
            }

            // 获取嘿文所有图片
            List<HeiImage> heiImages = getHeiImage(hei.getHeiId());
            if (heiImages != null) {
                hei.setImages(heiImages);
            }

            // 获取用户喜欢和收藏的嘿文 ID
            List<Integer> likeList = getHeiLikeIdByEmail(email);
            List<Integer> collectList = getHeiCollectIdByEmail(email);
            // 判断当前文章是否被用户喜欢/收藏
            hei.setLike(likeList.contains(hei.getHeiId()));
            hei.setCollect(collectList.contains(hei.getHeiId()));

            // 增加嘿文浏览量
            addViewById(hei.getHeiId());

            result.setContent(hei);
            return Common.toJson(result);
        } catch (Exception e) {
            e.printStackTrace();
            return Common.exceptionResults();
        }
    }

    /**
     * 增加嘿文浏览量
     * @param id 嘿文 ID
     */
    private void addViewById(int id) {
        try {
            heiDao.updateViews(id);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 根据指定学校获取嘿文
     * @param schoolName 学校名
     * @return List<hei>
     */
    public List<Hei> getHeiBySchool(String schoolName) {
        List<Hei> list;
        try {
            list = heiDao.selectHeiBySchool(schoolName);


            return list;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取所有嘿文
     * @return List<Hei>
     */
    public List<Hei> getAllHei() {
        List<Hei> list;
        try {
            list = heiDao.selectAllHei();
            return list;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }


    /**
     * 根据嘿文 ID 获取嘿文指定数量的图片
     * @param heiId 嘿文 ID
     * @param count 获取数量
     * @return List<HeiImage>
     */
    public List<HeiImage> getHeiImage(int heiId, int count) {
        List<HeiImage> list;
        try {
            list = heiDao.selectHeiImageByHeiId(heiId);
            if (count == -1) {
                // count == -1 默认返回所有图片
                return list;
            } else {
                // list 如果为空直接返回 null
                if (list == null || list.size() == 0) {
                    return null;
                }

                // 如果 count 大于等于 list 长度，直接返回 list
                if (count >= list.size()) {
                    return list;
                }

                List<HeiImage> heiImages = new ArrayList<>();
                for (int i = 0; i < count; i++) {
                    heiImages.add(list.get(i));
                }
                return heiImages;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 根据嘿文 ID 获取嘿文所有图片
     * @param heiId 嘿文 ID
     * @return List<HeiImage>
     */
    public List<HeiImage> getHeiImage(int heiId) {
        return getHeiImage(heiId, -1);
    }


    /**
     * 添加嘿文/修改嘿文（此方法修改嘿文仅适用附带新图片，如果只是单纯修改嘿文标题和内容需要使用 /hei/updateNoImg 接口）
     * @param email 邮箱
     * @param title 嘿文标题
     * @param content 嘿文内容
     * @param files 嘿文图片
     * @param token Token
     * @param heiId 嘿文 ID 如果此项不为空则表示为修改嘿文
     * @return Result
     */
    public String addHei(String email, String title, String content, List<MultipartFile> files, String token, String heiId) {
        Result result;
        try {
            result = tokenIsExpired(email, token);
            if (result.getStatus() != 0) {
                // Token 有问题，返回原因
                return Common.toJson(result);
            }

            // 嘿文图片不能为空
            if (files == null || files.size() == 0) {
                result.setStatus(-2);
                result.setMessage("嘿文图片为空");
                return Common.toJson(result);
            }

            // 先上传图片
            List<String> imageUrls = new ArrayList<>();
            for (MultipartFile file : files) {
                // 上传的图像原始文件名
                String fileName = file.getOriginalFilename();
                // 获取文件类型（后缀名）
                assert fileName != null;
                String fileType = fileName.substring(fileName.lastIndexOf("."));
                String newFileName = UUID.randomUUID() + fileType;

                // 上传图片
                File localFile = File.createTempFile("temp", null);
                file.transferTo(localFile);
                String imageUrl = MyCOSClient.uploadImage(localFile, email + "/" + newFileName);

                // 将图片地址存入数组
                imageUrls.add(imageUrl);
            }

            // 新增嘿文模式先向数据库插入嘿文数据
            Hei hei = new Hei();
            if (heiId.equals("")) {
                // 新建 Hei 并获取 heiId
                hei = new Hei();
                Date currentTime = new Date();
                hei.setEmail(email);
                hei.setTitle(title);
                hei.setContent(content);
                hei.setCreateTime(currentTime);
                // 获取用户的学校名
                String schoolName = userService.getUserByEmail(email).getSchoolName();
                hei.setSchoolName(schoolName);
                heiDao.insertHei(hei);
            } else {
                // 编辑模式
                hei.setHeiId(Integer.parseInt(heiId));
                hei.setTitle(title);
                hei.setContent(content);
                heiDao.updateHei(hei);
            }

            // 构建 HeiImage 数组
            List<HeiImage> heiImages = new ArrayList<>();
            for (String imageUrl: imageUrls) {
                HeiImage heiImage = new HeiImage();
                if (heiId.equals("")) {
                    // 新增模式获取刚才插入数据库的嘿文的 ID
                    heiImage.setHeiId(hei.getHeiId());
                } else {
                    // 编辑模式，获取传来的嘿文 ID
                    heiImage.setHeiId(Integer.parseInt(heiId));
                }
                heiImage.setSrc(imageUrl);
                heiImages.add(heiImage);
            }

            heiDao.insertHeiImage(heiImages);
            return Common.toJson(result);
        } catch (Exception e) {
            e.printStackTrace();
            result = new Result();
            result.setMessage("发布嘿文失败");
            result.setStatus(-2);
            return Common.toJson(result);
        }
    }


    /**
     * 修改嘿文的标题和内容
     * @param email 邮箱
     * @param title 标题
     * @param content 内容
     * @param heiId 嘿文 ID
     * @param token Token
     * @return Result
     */
    public String updateHeiTitleAndContent(String email, String title, String content, String heiId, String token) {
        Result result;
        try {
            result = tokenIsExpired(email, token);
            if (result.getStatus() != 0) {
                // Token 有问题，返回原因
                return Common.toJson(result);
            }
            Hei hei = new Hei();
            hei.setHeiId(Integer.parseInt(heiId));
            hei.setTitle(title);
            hei.setContent(content);
            heiDao.updateHei(hei);
            return Common.toJson(result);
        } catch (Exception e) {
            e.printStackTrace();
            return Common.exceptionResults();
        }
    }

    /**
     * 根据用户邮箱获取用户喜欢的文章(HeiLike)
     * @param email 邮箱
     * @return List<HeiLike>
     */
    private List<HeiLike> getHeiLikeByEmail(String email) {
        List<HeiLike> list;
        try {
            list = heiDao.selectHeiLikeByEmail(email);
            return list;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 根据用户邮箱获取用户喜欢的文章，获取文章 ID 数组
     * @param email 邮箱
     * @return List<Integer>
     */
    public List<Integer> getHeiLikeIdByEmail(String email) {
        List<HeiLike> list = getHeiLikeByEmail(email);
        List<Integer> resultList = new ArrayList<>();
        if (list != null) {
            list.forEach(heiLike -> resultList.add(heiLike.getHeiId()));
        }
        return resultList;
    }

    /**
     * 根据用户邮箱获取用户收藏的文章
     * @param email 邮箱
     * @return List<HeiCollect>
     */
    public List<HeiCollect> getHeiCollectByEmail(String email) {
        List<HeiCollect> list;
        try {
            list = heiDao.selectHeiCollectByEmail(email);
            return list;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 根据用户邮箱获取用户收藏的文章，获取文章 ID 数组
     * @param email 邮箱
     * @return List<Integer>
     */
    public List<Integer> getHeiCollectIdByEmail(String email) {
        List<HeiCollect> list = getHeiCollectByEmail(email);
        List<Integer> resultList = new ArrayList<>();
        if (list != null) {
            list.forEach(heiCollect -> resultList.add(heiCollect.getHeiId()));
        }
        return resultList;
    }


    /**
     * 检查 Token 是否不存在或者过期
     * @param email 邮箱
     * @param token Token
     * @return Result
     */
    private Result tokenIsExpired(String email, String token) {
        // 未传入 token
        if (token == null) {
            return Common.tokenIsNull();
        }
        Result tokenResult = loginTokenService.checkToken(email, token);
        if (tokenResult.getStatus() != 0) {
            // Token 已经过期
            return tokenResult;
        }
        return new Result();
    }

    /**
     * 根据邮箱和嘿文 ID 添加喜欢嘿文
     * @param email 邮箱
     * @param heiId 嘿文 ID
     * @param token Token
     * @return Result
     */
    public String addLike(String email, int heiId, String token) {
        Result result;
        try {
            result = tokenIsExpired(email, token);
            if (result.getStatus() != 0) {
                // Token 有问题，返回原因
                return Common.toJson(result);
            }

            heiDao.insertHeiLike(email, heiId);

            // 使用单独线程发送消息
            new Thread(() -> {
                // 刷新嘿文喜欢数量
                updateHeiLikeCountByHeiId(heiId);
                // 刷新用户喜欢数量
                updateUserLikeCountByEmail(email);

                // 给嘿文发布者发送点赞消息
                Hei hei = heiDao.selectHeiById(String.valueOf(heiId));
                // 如果是给自己点赞就不发送消息
                if (!email.equals(hei.getEmail())) {
                    messageService.addMessage(email, hei.getEmail(), Message.TYPE_LIKE, String.valueOf(heiId));
                }

            }).start();
            return Common.toJson(result);
        } catch (Exception e) {
            e.printStackTrace();
            return Common.exceptionResults();
        }
    }

    /**
     * 刷新用户喜欢数量
     * @param email 邮箱
     */
    private void updateUserLikeCountByEmail(String email) {
        try {
            // 获取用户喜欢数量
            int count = getUserLikeCountByEmail(email);

            // 更新用户喜欢数量
            heiDao.updateUserLikeCount(email ,count);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取用户喜欢数量
     * @param email 邮箱
     * @return 用户喜欢数量
     */
    private int getUserLikeCountByEmail(String email) {
        try {
            return heiDao.selectUserLikeCountByEmail(email);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 刷新嘿文喜欢数量
     * @param heiId 嘿文 ID
     */
    private void updateHeiLikeCountByHeiId(int heiId) {
        try {
            // 获取嘿文喜欢数量
            int count = getHeiLikeCountByHeiId(heiId);

            // 更新嘿文喜欢数量
            heiDao.updateHeiLikeCount(heiId ,count);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取嘿文喜欢数量
     * @param heiId 嘿文 ID
     * @return 嘿文喜欢数量
     */
    private int getHeiLikeCountByHeiId(int heiId) {
        try {
            return heiDao.selectHeiLikeCountByHeiId(heiId);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 根据邮箱和嘿文 ID 添加收藏嘿文
     * @param email 邮箱
     * @param heiId 嘿文 ID
     * @param token Token
     * @return Result
     */
    public String addCollect(String email, int heiId, String token) {
        Result result;
        try {
            result = tokenIsExpired(email, token);
            if (result.getStatus() != 0) {
                // Token 有问题，返回原因
                return Common.toJson(result);
            }

            heiDao.insertHeiCollect(email, heiId);

            // 使用单独线程处理其他数据
            new Thread(() -> {
                // 刷新嘿文收藏数量
                updateHeiCollectCountByHeiId(heiId);
                // 刷新用户收藏数量
                updateUserCollectCountByEmail(email);
            }).start();
            return Common.toJson(result);
        } catch (Exception e) {
            e.printStackTrace();
            return Common.exceptionResults();
        }
    }

    /**
     * 更新用户收藏数量
     * @param email 邮箱
     */
    private void updateUserCollectCountByEmail(String email) {
        try {
            // 获取用户收藏数量
            int count = getUserCollectCountByEmail(email);

            // 更新用户收藏数量
            heiDao.updateUserCollectCount(email, count);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取用户收藏数量
     * @param email 邮箱
     * @return 用户收藏数量
     */
    private int getUserCollectCountByEmail(String email) {
        try {
            return heiDao.selectUserCollectCountByEmail(email);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 刷新嘿文收藏数量
     * @param heiId 嘿文 ID
     */
    private void updateHeiCollectCountByHeiId(int heiId) {
        try {
            // 获取嘿文收藏数量
            int count = getHeiCollectCountByHeiId(heiId);

            // 更新嘿文收藏数量
            heiDao.updateHeiCollectCount(heiId, count);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取嘿文收藏数量
     * @param heiId 嘿文 ID
     * @return 嘿文收藏数量
     */
    private int getHeiCollectCountByHeiId(int heiId) {
        try {
            return heiDao.selectHeiCollectCountByHeiId(heiId);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 根据嘿文 ID 和用户邮箱删除用户喜欢的嘿文
     * @param email 邮箱
     * @param heiId 嘿文 ID
     * @param token Token
     * @return Result
     */
    public String deleteLike(String email, int heiId, String token) {
        Result result;
        try {
            result = tokenIsExpired(email, token);
            if (result.getStatus() != 0) {
                // Token 有问题，返回原因
                return Common.toJson(result);
            }

            heiDao.deleteHeiLike(email, heiId);

            // 单独线程处理其他数据
            new Thread(() -> {
                // 刷新嘿文喜欢数量
                updateHeiLikeCountByHeiId(heiId);
                // 刷新用户喜欢数量
                updateUserLikeCountByEmail(email);
            }).start();
            return Common.toJson(result);
        } catch (Exception e) {
            e.printStackTrace();
            return Common.exceptionResults();
        }
    }

    /**
     * 根据嘿文 ID 和用户邮箱删除用户收藏的嘿文
     * @param email 邮箱
     * @param heiId 嘿文 ID
     * @param token Token
     * @return Result
     */
    public String deleteCollect(String email, int heiId, String token) {
        Result result;
        try {
            result = tokenIsExpired(email, token);
            if (result.getStatus() != 0) {
                // Token 有问题，返回原因
                return Common.toJson(result);
            }

            heiDao.deleteHeiCollect(email, heiId);
            // 嘿文收藏数量 - 1
            deleteCollectionsById(heiId);

            // 用户收藏数量 - 1
            userService.deleteUserCollectionsByEmail(email);
            return Common.toJson(result);
        } catch (Exception e) {
            e.printStackTrace();
            return Common.exceptionResults();
        }
    }

    /**
     * 根据嘿文 ID 删除嘿文收藏数量
     * @param heiId 嘿文 ID
     */
    private void deleteCollectionsById(int heiId) {
        try {
            heiDao.updateCollectionsMinus(heiId);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 根据邮箱获取用户喜欢和收藏的嘿文 ID 数组
     * @param email 邮箱
     * @param token Token
     * @return Result
     */
    public String getLikeAndCollect(String email, String token) {
        Result result;
        try {
            result = tokenIsExpired(email, token);
            if (result.getStatus() != 0) {
                // Token 有问题，返回原因
                return Common.toJson(result);
            }

            List<HeiLike> heiLikes = getHeiLikeByEmail(email);
            List<HeiCollect> heiCollects = getHeiCollectByEmail(email);

            List<String> heiLikeList = new ArrayList<>();
            List<String> heiCollectList = new ArrayList<>();
            if (heiLikes != null) {
                for (HeiLike heiLike : heiLikes) {
                    heiLikeList.add(heiLike.getHeiId().toString());
                }
            }
            if (heiCollects != null) {
                for (HeiCollect heiCollect : heiCollects) {
                    heiCollectList.add(heiCollect.getHeiId().toString());
                }
            }

            JSONObject json = new JSONObject();
            json.put("likes", heiLikeList);
            json.put("collects", heiCollectList);

            result.setContent(json);
            return Common.toJson(result);
        } catch (Exception e) {
            e.printStackTrace();
            return Common.exceptionResults();
        }
    }

    /**
     * 根据邮箱获取用户喜欢的嘿文
     * @param email 邮箱
     * @param token Token
     * @return Result
     */
    public String getLikeHeiByEmail(String email, String token) {
        Result result;
        try {
            result = tokenIsExpired(email, token);
            if (result.getStatus() != 0) {
                // Token 有问题，返回原因
                return Common.toJson(result);
            }

            // 获取用户喜欢的嘿文 ID 数组(HeiLike)
            List<HeiLike> heiLikeList = getHeiLikeByEmail(email);
            if (heiLikeList == null || heiLikeList.size() == 0) {
                result.setContent(new ArrayList<>());
                return Common.toJson(result);
            }

            // 构造喜欢的嘿文的 ID 数组
            List<Integer> heiIds = new ArrayList<>();
            for (HeiLike heiLike : heiLikeList) {
                heiIds.add(heiLike.getHeiId());
            }

            // 根据嘿文 ID 获取嘿文
            List<Hei> heis = getHeiByIds(heiIds);

            result.setContent(heis);
            return Common.toJson(result);
        } catch (Exception e) {
            e.printStackTrace();
            return Common.exceptionResults();
        }
    }

    /**
     * 根据邮箱获取用户收藏的嘿文
     * @param email 邮箱
     * @param token Token
     * @return Result
     */
    public String getCollectHeiByEmail(String email, String token) {
        Result result;
        try {
            result = tokenIsExpired(email, token);
            if (result.getStatus() != 0) {
                // Token 有问题，返回原因
                return Common.toJson(result);
            }

            // 获取用户收藏的嘿文 ID 数组(HeiCollect)
            List<HeiCollect> heiCollectList = getHeiCollectByEmail(email);
            if (heiCollectList == null || heiCollectList.size() == 0) {
                result.setContent(new ArrayList<>());
                return Common.toJson(result);
            }

            // 构造收藏的嘿文的 ID 数组
            List<Integer> heiIds = new ArrayList<>();
            for (HeiCollect heiCollect : heiCollectList) {
                heiIds.add(heiCollect.getHeiId());
            }
            // 根据嘿文 ID 获取嘿文
            List<Hei> heis = getHeiByIds(heiIds);

            result.setContent(heis);
            return Common.toJson(result);
        } catch (Exception e) {
            e.printStackTrace();
            return Common.exceptionResults();
        }
    }

    /**
     * 根据嘿文 ID 获取嘿文
     * @param heiIds 嘿文 ID 数组
     * @return 嘿文数组
     */
    private List<Hei> getHeiByIds(List<Integer> heiIds) {
        List<Hei> heis;
        try {
            heis = heiDao.selectHeiByIds(heiIds);

            // 根据嘿文 ID 获取对应的嘿文图像
            // 因为这里是批量获取嘿文，所以只获取不大于一张图片
            heis = getHeiAndImageByHeiList(heis, 1);
            return heis;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 根据用户邮箱获取用户的嘿文
     * @param email 自己的邮箱
     * @param byEmail 要查询的邮箱
     * @param token Token
     * @return Result
     */
    public String getHeiByEmail(String email, String byEmail, String token) {
        Result result;
        try {
            result = tokenIsExpired(email, token);
            if (result.getStatus() != 0) {
                // Token 有问题，返回原因
                return Common.toJson(result);
            }

            List<Hei> heis = heiDao.selectHeiByEmail(byEmail);

            if (heis == null || heis.size() == 0) {
                result.setContent(new ArrayList<>());
            } else {
                // 根据嘿文 ID 获取对应的嘿文图像
                result.setContent(getHeiAndImageByHeiList(heis, 1));
            }
            return Common.toJson(result);
        } catch (Exception e) {
            e.printStackTrace();
            return Common.exceptionResults();
        }
    }

    /**
     * 给传入的嘿文数组中的每个嘿文加入嘿文的图片，并返回包装好的嘿文数组
     * @param heis 嘿文数组
     * @param count 嘿文包含的图片，0 默认包含所有图片
     * @return List<Hei>
     */
    private List<Hei> getHeiAndImageByHeiList(List<Hei> heis, int count) {
        if (heis == null) {
            return new ArrayList<>();
        }
        for (int i = 0; i < heis.size(); i++) {
            Hei hei = heis.get(i);
            List<HeiImage> heiImages;
            if (count != 0) {
                // 获取指定数量图片
                heiImages = getHeiImage(hei.getHeiId(), count);
            } else {
                // 默认获取嘿文的所有图片
                heiImages = getHeiImage(hei.getHeiId());
            }
            if (heiImages != null) {
                hei.setImages(heiImages);
            }
            heis.set(i, hei);
        }
        return heis;
    }

    /**
     * 根据邮箱获取嘿文数量
     * @param email 邮箱
     * @param token Token
     * @return Result
     */
    public String getHeiCount(String email, String token) {
        Result result;
        try {
            result = tokenIsExpired(email, token);
            if (result.getStatus() != 0) {
                // Token 有问题，返回原因
                return Common.toJson(result);
            }

            int count = heiDao.selectHeiCountByEmail(email);
            result.setContent(count);
            return Common.toJson(result);
        } catch (Exception e) {
            e.printStackTrace();
            return Common.exceptionResults();
        }
    }

    /**
     * 根据嘿文 ID 删除黑恩
     * @param email 邮箱
     * @param heiId 嘿文 ID
     * @param token Token
     * @return Result
     */
    public String removeHei(String email, String heiId, String token) {
        Result result;
        try {
            result = tokenIsExpired(email, token);
            if (result.getStatus() != 0) {
                // Token 有问题，返回原因
                return Common.toJson(result);
            }
            // 先尝试能否获取到嘿文
            Hei hei = heiDao.selectHeiById(heiId);
            if (hei == null) {
                return Common.toJson(result);
            }

            // 删除 hei 数据库数据
            heiDao.deleteHeiByHeiId(heiId);

            // 单独的线程处理其他数据
            new Thread(() -> {
                // 获取嘿文所有图片
                List<HeiImage> heiImages = getHeiImage(hei.getHeiId());
                // 构造 HeiImageId 数组
                List<Integer> heiImageIds = new ArrayList<>();
                if (heiImages != null && heiImages.size() > 0) {
                    // 删除对象存储中的图片
                    for (HeiImage heiImage : heiImages) {
                        // 获取图片在对象存储中相对地址
                        String path = Common.getIntermediateText(heiImage.getSrc(), "Heba/", "");
                        MyCOSClient.deleteFile(path);

                        heiImageIds.add(heiImage.getHeiImageId());
                    }
                    // 删除 heiImage 数据库数据
                    heiDao.deleteHeiImageByIds(heiImageIds);
                }

                // 根据嘿文 ID 删除所有收藏和喜欢该嘿文的数据
                heiDao.deleteHeiLikeByHeiId(hei.getHeiId());
                heiDao.deleteHeiCollectByHeiId(hei.getHeiId());
            }).start();
            // 获取嘿文的所有图片
            return Common.toJson(result);
        } catch (Exception e) {
            e.printStackTrace();
            return Common.exceptionResults();
        }
    }

    /**
     * 根据嘿文图片 ID 删除图片
     * @param email 邮箱
     * @param heiImageId 嘿文图片 ID
     * @param token Token
     * @return Result
     */
    public String removeHeiImageById(String email, String heiImageId, String token) {
        Result result;
        try {
            result = tokenIsExpired(email, token);
            if (result.getStatus() != 0) {
                // Token 有问题，返回原因
                return Common.toJson(result);
            }

            // 获取 HeiImage
            HeiImage heiImage = heiDao.getHeiImageByImageId(heiImageId);
            if (heiImage == null) {
                // 图片不存在，直接返回 OK
                return Common.toJson(result);
            }

            // 删除数据库图片数据
            List<Integer> imageIds = new ArrayList<>();
            imageIds.add(heiImage.getHeiImageId());
            heiDao.deleteHeiImageByIds(imageIds);

            // 单独线程删除对象存储中图片
            new Thread(() -> MyCOSClient.deleteFile(Common.getIntermediateText(heiImage.getSrc(), "Heba/", ""))).start();
            return Common.toJson(result);
        } catch (Exception e) {
            e.printStackTrace();
            return Common.exceptionResults();
        }
    }


    /**
     * 根据嘿文 ID 刷新嘿文评论数量
     * @param heiId 嘿文 ID
     */
    public void updateHeiCommentCountByHeiId(int heiId) {
        try {
            int count = selectHeiCommentCountByHeiId(heiId);

            // 更新嘿文评论数量
            heiDao.updateHeiComments(heiId, count);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 根据嘿文 ID 获取嘿文评论数量
     * @param heiId 嘿文 ID
     * @return 评论数量
     */
    private int selectHeiCommentCountByHeiId(int heiId) {
        try {
            return heiDao.selectHeiCommentCountByHeiId(heiId);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
}
